'use strict';
 
// function string2int(s){
//     var arrStr = s.split(''); //把字符串分割成字符串数组
//     var arrInt = arrStr.map(function(x){ //通过map()把字符串数组转换成数字数组
//         return + x;
//     });
//     return arrInt.reduce(function(x,y){ //通过reduce()把数字数组转换成数字量
//         return x*10+y;
//     });
// }

// // 测试:
// if (string2int('0') === 0 && string2int('12345') === 12345 && string2int('12300') === 12300) {
//     if (string2int.toString().indexOf('parseInt') !== -1) {
//         alert('请勿使用parseInt()!');
//     } else if (string2int.toString().indexOf('Number') !== -1) {
//         alert('请勿使用Number()!');
//     } else {
//         alert('测试通过!');
//     }
// }
// else {
//     alert('测试失败!');
// }

//注意：map()是数组Array的一个方法，传入一个指定方法，返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组

//Array的reduce()把一个函数作用在这个Array的[x1, x2, x3...]上，这个函数必须接收两个参数，reduce()把结果继续和序列的下一个元素做累积计算，其效果就是：

//[x1, x2, x3, x4].reduce(f) = f(f(f(x1, x2), x3), x4)


//1
// var arr = [1,2,3,4,5];
// var sum = arr.reduce(function(prev,cur,index,arr){
//     console.log(prev,cur,index);
//     return prev + cur;
// });
// console.log(arr,sum);
//这里可以看出，上面的例子index是从1开始的，第一次的prev的值是数组的第一个值。数组长度是4，但是reduce函数循环3次。

//2
// var arr = [1,2,3,4,5];
// var sum =arr.reduce(function(prve,cur,index,arr){
//     console.log(prve,cur,index);
//     return prve + cur;
// },0);
// console.log(arr,sum);
//这个例子index是从0开始的，第一次的prev的值是我们设置的初始值0，数组长度是4，reduce函数循环4次


//但是要是我们设置了初始值就不会报错，
// var arr =[];

// var sum = arr.reduce(function(prve,cur,index,arr){
//     console.log(prev,cur,index);
//     return prve + cur;
// },0);

// console.log(arr,sum); //[]0

//reduce的简单用法， 当然最简单的就是我们常用的数组求和，求乘积了。

// var arr = [1,2,3,4];
// var sum = arr.reduce((x,y)=>x+y);
// var mul = arr.reduce((x,y)=>x*y);
// console.log(sum); //求和 10
// console.log(mul);  // 求乘积 24


//reduce的高级用法 （1）计算数组中每个元素出现的次数

// let name =['詹姆斯','浓眉','科比','字母歌','詹姆斯'];

// let nameNum = name.reduce((pre,cur)=>{
//     if(cur in pre){
//         pre[cur]++
//     }else{
//         pre[cur]=1;
//     }
//     return pre;
// },{});
// console.log(nameNum);



//数组去重
// let arr = [1,2,3,4,5,5,6,6];

// let newarr= arr.reduce((pre,cur)=>{
//     if(!pre.includes(cur)){
//         return pre.concat(cur);
//     }else{
//         return pre;
//     }
// },[]);
// console.log(newarr);//(6) [1, 2, 3, 4, 5, 6]


//将二维数组转化为一维

// let arr = [[0,1],[2,3],[4,[5,6,7]]];

// const newArr = function(arr){
//     return arr.reduce((pre,cur)=>pre.concat(Array.isArray(cur)?newArr(cur):cur),[]);
// }
// console.log(newArr(arr));//[0, 1, 2, 3, 4, 5, 6, 7]

//对象里的属性求和

// var result = [
//     {
//     name:'詹姆斯',
//     score:40
//     },
//     {
//         name:'浓眉',
//         score:35
//     },
//     {
//         name:'科比',
//         score:50
//     }
// ];
// var sum = result.reduce(function(prve,cur){
//     return cur.score + prve;
// },0);
// console.log(sum);//125



//数组对象的去重
// let person = [
//     {id: 0, name: "小明"},
//     {id: 1, name: "小张"},
//     {id: 2, name: "小李"},
//     {id: 3, name: "小孙"},
//     {id: 1, name: "小周"},
//     {id: 2, name: "小陈"},   
// ];

// let obj = {};

// person = person.reduce((cur,next) => {
//    obj[next.id] ? "" : obj[next.id] = true && cur.push(next);
//    return cur;
// },[]) //设置cur默认类型为数组，并且初始值为空的数组
// console.log(person);  //这样就可以得到返回的数组是去重的结果




//请把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。
//输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']。

// function normalize(arr) {
//     function correct(word){
//         var list ='';
//         for(var i=0;i<word.length;i++){
//             if(i === 0)
//                 list += word[i].toUpperCase();
//             else
//                list += word[i].toLowerCase();
//         }

//         return list;
//     }

//     return arr.map(correct);

// }
// //alert(normalize(['adam', 'LISA', 'barT']));


// // 测试:
// if (normalize(['adam', 'LISA', 'barT']).toString() === ['Adam', 'Lisa', 'Bart'].toString()) {
//     console.log('测试通过!');
// }
// else {
//     console.log('测试失败!');
// }

var v = `
-----------------
吵死了！！！！！
-----------------
`
console.log(v);
/*输出描述
如果数组中存在item 则返回元素在数组中的位置，是否返回-1
输入：[1,2,3,4],3
输出： 2
*/

// function indexOf(arr,item){
//     if(Array.prototype.indexOf){
//         return arr.indexOf(item);
//     }else{
//         for(var i =0;i<arr.length;i++){
//             if(arr[i] === item){ //找到就返回在数组中的位置
//                 return i;
//             }
//         }
//     }
//     return -1;//未找到就返回-1
// }
// console.log([1,2,3,4],3);


// /*数组求和
// 计算给定数组arr中所有元素的总和

// 数组中的元素均为Number类型
// */

// function sum(arr){
//     var s = 0;
//     for(var i =arr.length-1;i>=0;i--){
//         s += arr[i];
//     }
//     return s;
// }
// console.log([1,2,3,4]);


function MyArray(){
    let string = "";
    //记录当前数组中元素的个数
    let len = 0;
    for(let arr in arguments){
        string = string + arguments[arr] + ",";
        len++;
    }
    let str = string.substring(0,string.length-1);

    //a.toString();
    this.toString = function(){
        return str;
    }

    //a.length;
    this.length = len;

    //a[a.length - 1];
    for(let j = 0; j<len; j++){
        this[j] = (function(j){
            if(j == 0){//数组下标为0的元素
                var index_comma = str.indexOf(',');
                var aimStr = str.substring(0,index_comma);
                return aimStr;   
            }else if(j < len - 1){//中间的元素
                    //计数，记录逗号的检索次数
                    let count = 0;
                    //分别表示逗号的相对位置，目标字符串的绝对位置
                    var index_comma, index_begin, index_end;
                    //累加，始终是检索到的逗号后的一个字符的索引(绝对位置)
                    var index_add = 0;
                    index_comma = str.indexOf(',');
                    //从逗号后开始
                    index_add = index_comma + 1;
                    var strSlice = str.substring(index_add, str.length);
                    count++;
                    for(let i=0; i<len; i++){
                        if( count == j){
                            index_begin = index_add;
                       }
                       if( count == j+1){
                            index_end = index_add-1;
                       }

                        index_comma = strSlice.indexOf(',');
                        index_add += (index_comma + 1);
                        var strSlice = str.substring(index_add, str.length); 
                        //为逗号计数
                        count++;
                    }
                    //不包括前一个逗号
                    var aimStr = str.substring(index_begin,index_end);
                    //这是中间的
                    return aimStr;
            }else if(j == len-1){
                var index_comma = str.lastIndexOf(',');
                var aimStr = str.substring(index_comma + 1,str.length);
                //下标length-1
                return aimStr;
            }
        })(j);
        //有好几种可能的情况：1.要分离是第一个元素 2.要分离的是最后一个元素 3.分离的是中间的元素（夹在两个逗号之间）
        //这三个应该是if(){}else if(){}else{}这样的结构
        //值得注意的点有：substring左开右闭
        //采用裁取的方法，绝对索引用前一个的绝对索引加上当前的相对索引得到
    }

    //this.push();
    this.push = function(string){
        str = str + "," + string;
        this[len.length-1] = string;
        len++;
        return len;
    }

    //this.pop()
    this.pop = function(){
        var index_comma = str.lastIndexOf(',');
        var aimStr = str.substring(index_comma+1,str.length);
        str = str.substring(0,index_comma);
        delete this[len - 1];
        len--;
        return '['+aimStr+']';
    }

    //this.join()
    this.join = function(string){
        let strJoin = '';
        strJoin += this[0];
        for(let j = 1; j < len; j++){
            strJoin = strJoin + string + this[j];
        }
        return strJoin;
    }
}